// Original: Base Commerce Payments (MIT License)

// Modifications: Copyright 2025-2026 Ali Abdoli and Vrajang Parikh (BUSL-1.1)

pragma solidity ^0.8.28;

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";

import {LibClone} from "solady/utils/LibClone.sol";

import {TokenStore} from "./TokenStore.sol";

import {TokenCollector} from "./collectors/TokenCollector.sol";

/// @title AuthCaptureEscrow

///

/// @notice Facilitate payments through an escrow.

///

/// @dev By escrowing payment, this contract can mimic the 2-step payment pattern of "authorization" and "capture".

/// @dev Authorization is defined as placing a hold on a payer's funds temporarily.

/// @dev Capture is defined as distributing payment to the end recipient.

/// @dev An Operator plays the role of facilitating state transitions associated with a payment, constrained by cryptographic authorization

///      from a payer and confirmation signals from the merchant.

///

/// @author Coinbase (https://github.com/base/commerce-payments)

    using SafeERC20 for IERC20;

    /// @notice Payment info, contains all information required to authorize and capture a unique payment

    struct PaymentInfo {

        /// @dev Entity responsible for driving payment flow

        address operator;

        /// @dev The payer's address authorizing the payment

        address payer;

        /// @dev Address that receives the payment (minus fees)

        address receiver;

        /// @dev The token contract address

        address token;

        /// @dev The amount of tokens that can be authorized

        uint120 maxAmount;

        /// @dev Timestamp when the payer's pre-approval can no longer authorize payment

        uint48 preApprovalExpiry;

        /// @dev Timestamp when an authorization can no longer be captured and the payer can reclaim from escrow

        uint48 authorizationExpiry;

        /// @dev Timestamp when a successful payment can no longer be refunded

        uint48 refundExpiry;

        /// @dev Minimum fee percentage in basis points

        uint16 minFeeBps;

        /// @dev Maximum fee percentage in basis points

        uint16 maxFeeBps;

        /// @dev Address that receives the fee portion of payments, if 0 then operator can set at capture

        address feeReceiver;

        /// @dev A source of entropy to ensure unique hashes across different payments

        uint256 salt;

    }

    /// @notice State for tracking payments through lifecycle

    struct PaymentState {

        /// @dev True if payment has been authorized or charged

        bool hasCollectedPayment;

        /// @dev Amount of tokens currently on hold in escrow that can be captured

        uint120 capturableAmount;

        /// @dev Amount of tokens previously captured that can be refunded

        uint120 refundableAmount;

    }

    /// @notice Typehash used for hashing PaymentInfo structs

        "PaymentInfo(address operator,address payer,address receiver,address token,uint120 maxAmount,uint48 preApprovalExpiry,uint48 authorizationExpiry,uint48 refundExpiry,uint16 minFeeBps,uint16 maxFeeBps,address feeReceiver,uint256 salt)"

    );

    /// @notice Implementation contract for operator token stores

    /// @notice State per unique payment

    mapping(bytes32 paymentInfoHash => PaymentState state) public paymentState;

    /// @notice Emitted when a payment is charged and immediately captured

    event PaymentCharged(

        bytes32 indexed paymentInfoHash,

        PaymentInfo paymentInfo,

        uint256 amount,

        address tokenCollector,

        uint16 feeBps,

        address feeReceiver

    );

    /// @notice Emitted when authorized (escrowed) amount is increased

    event PaymentAuthorized(

        bytes32 indexed paymentInfoHash, PaymentInfo paymentInfo, uint256 amount, address tokenCollector

    );

    /// @notice Emitted when payment is captured from escrow

    event PaymentCaptured(bytes32 indexed paymentInfoHash, uint256 amount, uint16 feeBps, address feeReceiver);

    /// @notice Emitted when an authorized payment is voided, returning any escrowed funds to the payer

    event PaymentVoided(bytes32 indexed paymentInfoHash, uint256 amount);

    /// @notice Emitted when part of an authorized payment is voided, returning partial escrowed funds to the payer

    /// @dev Added by BackTrackCo for partial pre-capture refund support

    event PaymentPartiallyVoided(bytes32 indexed paymentInfoHash, uint256 amount, uint256 remainingCapturable);

    /// @notice Emitted when an authorized payment is reclaimed, returning any escrowed funds to the payer

    event PaymentReclaimed(bytes32 indexed paymentInfoHash, uint256 amount);

    /// @notice Emitted when a captured payment is refunded

    event PaymentRefunded(bytes32 indexed paymentInfoHash, uint256 amount, address tokenCollector);

    /// @notice Event emitted when new token store is created

    event TokenStoreCreated(address indexed operator, address tokenStore);

    /// @notice Sender for a function call does not follow access control requirements

    error InvalidSender(address sender, address expected);

    /// @notice Amount is zero

    error ZeroAmount();

    /// @notice Amount overflows allowed storage size of uint120

    error AmountOverflow(uint256 amount, uint256 limit);

    /// @notice Requested authorization amount exceeds `PaymentInfo.maxAmount`

    error ExceedsMaxAmount(uint256 amount, uint256 maxAmount);

    /// @notice Authorization attempted after pre-approval expiry

    error AfterPreApprovalExpiry(uint48 timestamp, uint48 expiry);

    /// @notice Expiry timestamps violate preApproval <= authorization <= refund

    error InvalidExpiries(uint48 preApproval, uint48 authorization, uint48 refund);

    /// @notice Fee bips overflows 10_000 maximum

    error FeeBpsOverflow(uint16 feeBps);

    /// @notice Fee bps range invalid due to min > max

    error InvalidFeeBpsRange(uint16 minFeeBps, uint16 maxFeeBps);

    /// @notice Fee bps outside of allowed range

    error FeeBpsOutOfRange(uint16 feeBps, uint16 minFeeBps, uint16 maxFeeBps);

    /// @notice Fee receiver is zero address with a non-zero fee

    error ZeroFeeReceiver();

    /// @notice Fee recipient cannot be changed

    error InvalidFeeReceiver(address attempted, address expected);

    /// @notice Token collector is not valid for the operation

    error InvalidCollectorForOperation();

    /// @notice Token pull failed

    error TokenCollectionFailed();

    /// @notice Charge or authorize attempted on a payment has already been collected

    error PaymentAlreadyCollected(bytes32 paymentInfoHash);

    /// @notice Capture attempted at or after authorization expiry

    error AfterAuthorizationExpiry(uint48 timestamp, uint48 expiry);

    /// @notice Capture attempted with insufficient authorization amount

    error InsufficientAuthorization(bytes32 paymentInfoHash, uint256 authorizedAmount, uint256 requestedAmount);

    /// @notice Void or reclaim attempted with zero authorization amount

    error ZeroAuthorization(bytes32 paymentInfoHash);

    /// @notice Partial void amount exceeds capturable amount

    /// @dev Added by BackTrackCo for partial pre-capture refund support

    error PartialVoidExceedsCapturable(uint256 requested, uint256 available);

    /// @notice Reclaim attempted before authorization expiry

    error BeforeAuthorizationExpiry(uint48 timestamp, uint48 expiry);

    /// @notice Refund attempted at or after refund expiry

    error AfterRefundExpiry(uint48 timestamp, uint48 expiry);

    /// @notice Refund attempted with amount exceeding previous non-refunded captures

    error RefundExceedsCapture(uint256 refund, uint256 captured);

    /// @notice Check call sender is specified address

    ///

    /// @param sender Address to enforce is the call sender

    modifier onlySender(address sender) {

        _;

    }

    /// @notice Ensures amount is non-zero and does not overflow storage

    ///

    /// @param amount Quantity of tokens being requested for a given operation

    modifier validAmount(uint256 amount) {

        _;

    }

    /// @notice Constructor that auto-deploys TokenStore implementation to clone

    constructor() {

    }

    /// @notice Transfers funds from payer to receiver in one step

    ///

    /// @dev If amount is less than the authorized amount, only amount is taken from payer

    /// @dev Reverts if the authorization has been voided or expired

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Amount to charge and capture

    /// @param tokenCollector Address of the token collector

    /// @param collectorData Data to pass to the token collector

    /// @param feeBps Fee percentage to apply (must be within min/max range)

    /// @param feeReceiver Address to receive fees (should match the paymentInfo.feeReceiver unless that is 0 in which case it can be any address)

    function charge(

        PaymentInfo calldata paymentInfo,

        uint256 amount,

        address tokenCollector,

        bytes calldata collectorData,

        uint16 feeBps,

        address feeReceiver

        // Check payment info valid

        _validatePayment(paymentInfo, amount);

        // Check fee parameters valid

        // Check payment not already collected

        // Set payment state with refundable amount

        paymentState[paymentInfoHash] =

        // Transfer tokens into escrow

        _collectTokens(paymentInfo, amount, tokenCollector, collectorData, TokenCollector.CollectorType.Payment);

        // Transfer tokens to receiver and fee receiver

    }

    /// @notice Transfers funds from payer to escrow

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Amount to authorize

    /// @param tokenCollector Address of the token collector

    /// @param collectorData Data to pass to the token collector

    function authorize(

        PaymentInfo calldata paymentInfo,

        uint256 amount,

        address tokenCollector,

        bytes calldata collectorData

        // Check payment info valid

        _validatePayment(paymentInfo, amount);

        // Check payment not already collected

        // Set payment state with capturable amount

        paymentState[paymentInfoHash] =

        // Transfer tokens into escrow

        _collectTokens(paymentInfo, amount, tokenCollector, collectorData, TokenCollector.CollectorType.Payment);

    }

    /// @notice Transfer previously-escrowed funds to receiver

    ///

    /// @dev Can be called multiple times up to cumulative authorized amount

    /// @dev Can only be called by the operator

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Amount to capture

    /// @param feeBps Fee percentage to apply (must be within min/max range)

    /// @param feeReceiver Address to receive fees (should match the paymentInfo.feeReceiver unless that is 0 in which case it can be any address)

    function capture(PaymentInfo calldata paymentInfo, uint256 amount, uint16 feeBps, address feeReceiver)

        external

        nonReentrant

        validAmount(amount)

    {

        // Check fee parameters valid

        // Check before authorization expiry

        }

        // Check sufficient escrow to capture

        PaymentState memory state = paymentState[paymentInfoHash];

        }

        // Update payment state, converting capturable amount to refundable amount

        state.refundableAmount += uint120(amount);

        paymentState[paymentInfoHash] = state;

        // Transfer tokens to receiver and fee receiver

    }

    /// @notice Permanently voids a payment authorization

    ///

    /// @dev Returns any escrowed funds to payer

    /// @dev Can only be called by the operator

    ///

    /// @param paymentInfo PaymentInfo struct

        // Check authorization non-zero

        uint256 authorizedAmount = paymentState[paymentInfoHash].capturableAmount;

        // Clear capturable amount state

        paymentState[paymentInfoHash].capturableAmount = 0;

        // Transfer tokens to payer from token store

    }

    /// @notice Partially voids a payment authorization, returning a portion of escrowed funds to payer

    ///

    /// @dev Unlike void() which returns all escrowed funds, this allows partial refunds before capture

    /// @dev Can only be called by the operator

    /// @dev Added by BackTrackCo for partial pre-capture refund support

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Amount to return to payer (must be <= capturableAmount)

    function partialVoid(PaymentInfo calldata paymentInfo, uint120 amount)

        external

        nonReentrant

        validAmount(amount)

    {

        uint120 capturableAmount = paymentState[paymentInfoHash].capturableAmount;

        // Check requested amount does not exceed available

        // Reduce capturable amount

        // Transfer tokens to payer from token store

    }

    /// @notice Returns any escrowed funds to payer

    ///

    /// @dev Can only be called by the payer and only after the authorization expiry

    ///

    /// @param paymentInfo PaymentInfo struct

        // Check not before authorization expiry

        }

        // Check authorization non-zero

        uint256 authorizedAmount = paymentState[paymentInfoHash].capturableAmount;

        // Clear capturable amount state

        paymentState[paymentInfoHash].capturableAmount = 0;

        // Transfer tokens to payer from token store

    }

    /// @notice Return previously-captured tokens to payer

    ///

    /// @dev Can be called by operator

    /// @dev Funds are transferred from the caller or from the escrow if token collector retrieves external liquidity

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Amount to refund

    /// @param tokenCollector Address of the token collector

    /// @param collectorData Data to pass to the token collector

    function refund(

        PaymentInfo calldata paymentInfo,

        uint256 amount,

        address tokenCollector,

        bytes calldata collectorData

        // Check refund has not expired

        }

        // Limit refund amount to previously captured

        uint120 captured = paymentState[paymentInfoHash].refundableAmount;

        // Update refundable amount

        // Transfer tokens into escrow and forward to payer

    }

    /// @notice Get hash of PaymentInfo struct

    ///

    /// @dev Includes chainId and verifyingContract in hash for cross-chain and cross-contract uniqueness

    ///

    /// @param paymentInfo PaymentInfo struct

    ///

    /// @return Hash of payment info for the current chain and contract address

    }

    /// @notice Get the token store address for an operator

    ///

    /// @param operator The operator to get the token store for

    ///

    /// @return The operator's token store address

        return LibClone.predictDeterministicAddress({

            salt: bytes32(bytes20(operator)),

        });

    }

    /// @notice Transfer tokens into this contract

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Amount of tokens to collect

    /// @param tokenCollector Address of the token collector

    /// @param collectorData Data to pass to the token collector

    /// @param collectorType Type of collector to enforce (payment or refund)

    function _collectTokens(

        PaymentInfo calldata paymentInfo,

        uint256 amount,

        address tokenCollector,

        bytes calldata collectorData,

        TokenCollector.CollectorType collectorType

    ) internal {

        // Check token collector matches required type

        // Measure balance change of token store to enforce as equal to expected amount

    }

    /// @notice Send tokens from an operator's token store

    ///

    /// @param operator The operator whose token store to use

    /// @param token The token to send

    /// @param recipient Address to receive the tokens

    /// @param amount Amount of tokens to send

        // Attempt to transfer tokens

            // Call failed from undeployed TokenStore, deploy and try again

            tokenStore = LibClone.cloneDeterministic({

                salt: bytes32(bytes20(operator))

            });

        } else {

            // Call failed from revert, bubble up data

                let returnDataSize := mload(returnData)

                revert(add(32, returnData), returnDataSize)

            }

        }

    }

    /// @notice Sends tokens to receiver and/or feeReceiver

    ///

    /// @param token Token to transfer

    /// @param receiver Address to receive payment

    /// @param amount Total amount to split between payment and fees

    /// @param feeBps Fee percentage in basis points

    /// @param feeReceiver Address to receive fees

        internal

    {

        uint256 feeAmount = amount * feeBps / _MAX_FEE_BPS;

        // Send fee portion if non-zero

        // Send remaining amount to receiver

    }

    /// @notice Validates required properties of a payment

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param amount Token amount to validate against

    function _validatePayment(PaymentInfo calldata paymentInfo, uint256 amount) internal view {

        // Check amount does not exceed maximum

        // Timestamp comparisons cannot overflow uint48

        // Check expiry timestamps properly ordered

        }

        // Check fee bps do not exceed maximum value

        // Check min fee bps does not exceed max fee

    }

    /// @notice Validates attempted fee adheres to constraints set by payment info

    ///

    /// @param paymentInfo PaymentInfo struct

    /// @param feeBps Fee percentage in basis points

    /// @param feeReceiver Address to receive fees

        // Check fee bps within [min, max]

        // Check fee recipient only zero address if zero fee bps

        // Check fee receiver matches payment info if non-zero

        }

    }

    /// @dev Override to use transient reentrancy guard on all chains

    function _useTransientReentrancyGuardOnlyOnMainnet() internal view virtual override returns (bool) {

        return false;

    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.28;

import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @title TokenStore

///

/// @notice Holds funds for payments associated with a single operator

///

/// @dev Deployed on demand by AuthCaptureEscrow via CREATE2 clones

///

/// @author Coinbase (https://github.com/base/commerce-payments)

    /// @notice AuthCaptureEscrow singleton that created this token store

    /// @notice Call sender is not AuthCaptureEscrow

    error OnlyAuthCaptureEscrow();

    /// @notice Constructor

    /// @param authCaptureEscrow_ AuthCaptureEscrow singleton that created this token store

    constructor(address authCaptureEscrow_) {

    }

    /// @notice Send tokens to a recipient, called by escrow during capture/refund

    ///

    /// @param token The token being received

    /// @param recipient Address to receive the tokens

    /// @param amount Amount of tokens to receive

    ///

    /// @return success True if the transfer was successful

    function sendTokens(address token, address recipient, uint256 amount) external returns (bool) {

        SafeERC20.safeTransfer(IERC20(token), recipient, amount);

        return true;

    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.28;

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {TokenCollector} from "./TokenCollector.sol";

import {AuthCaptureEscrow} from "../AuthCaptureEscrow.sol";

/// @title PreApprovalPaymentCollector

///

/// @notice Collect payments using pre-approval calls and ERC-20 allowances

///

/// @author Coinbase (https://github.com/base/commerce-payments)

    /// @inheritdoc TokenCollector

    TokenCollector.CollectorType public constant override collectorType = TokenCollector.CollectorType.Payment;

    /// @notice Payment was pre-approved by payer

    event PaymentPreApproved(bytes32 indexed paymentInfoHash);

    /// @notice Payment not pre-approved by payer

    error PaymentNotPreApproved(bytes32 paymentInfoHash);

    /// @notice Payment already collected

    error PaymentAlreadyCollected(bytes32 paymentInfoHash);

    /// @notice Payment already pre-approved by payer

    error PaymentAlreadyPreApproved(bytes32 paymentInfoHash);

    /// @notice Track if a payment has been pre-approved

    mapping(bytes32 paymentInfoHash => bool approved) public isPreApproved;

    /// @notice Constructor

    ///

    /// @param authCaptureEscrow_ AuthCaptureEscrow singleton that calls to collect tokens

    constructor(address authCaptureEscrow_) TokenCollector(authCaptureEscrow_) {}

    /// @notice Registers payer's token approval for a specific payment

    ///

    /// @dev Must be called by the payer specified in the payment info

    ///

    /// @param paymentInfo PaymentInfo struct

    function preApprove(AuthCaptureEscrow.PaymentInfo calldata paymentInfo) external {

        // Check sender is payer

        // Check pre-approval expiry has not passed

        }

        // Check has not already pre-approved

        // Check has not already collected

        // Set payment as pre-approved

    }

    /// @inheritdoc TokenCollector

    ///

    /// @dev Requires pre-approval for a specific payment and an ERC-20 allowance to this collector

    function _collectTokens(

        AuthCaptureEscrow.PaymentInfo calldata paymentInfo,

        address tokenStore,

        uint256 amount,

        bytes calldata

    ) internal override {

        // Check payment pre-approved

        // Skip resetting pre-approval to save gas as the `AuthCaptureEscrow` enforces unique, single-lifecycle payments

        // Transfer tokens from payer directly to token store

    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.28;

import {AuthCaptureEscrow} from "../AuthCaptureEscrow.sol";

/// @title TokenCollector

///

/// @notice Abstract contract for shared token collector utilities

///

/// @author Coinbase (https://github.com/base/commerce-payments)

abstract contract TokenCollector {

    /// @notice Type differentiation between payment and refund collection flows

    enum CollectorType {

        Payment,

        Refund

    }

    /// @notice AuthCaptureEscrow singleton

    /// @notice Call sender is not AuthCaptureEscrow

    error OnlyAuthCaptureEscrow();

    /// @notice Constructor

    ///

    /// @param authCaptureEscrow_ AuthCaptureEscrow singleton that calls to collect tokens

    constructor(address authCaptureEscrow_) {

    }

    /// @notice Pull tokens from payer to escrow using token collector-specific authorization logic

    ///

    /// @param paymentInfo Payment info struct

    /// @param tokenStore Address to collect tokens into

    /// @param amount Amount of tokens to pull

    /// @param collectorData Data to pass to the token collector

    function collectTokens(

        AuthCaptureEscrow.PaymentInfo calldata paymentInfo,

        address tokenStore,

        uint256 amount,

        bytes calldata collectorData

    ) external {

        _collectTokens(paymentInfo, tokenStore, amount, collectorData);

    }

    /// @notice Get the type of token collector

    ///

    /// @return CollectorType Type of token collector

    function collectorType() external view virtual returns (CollectorType);

    /// @notice Pull tokens from payer to escrow using token collector-specific authorization logic

    ///

    /// @param paymentInfo Payment info struct

    /// @param tokenStore Address to collect tokens into

    /// @param amount Amount of tokens to pull

    /// @param collectorData Data to pass to the token collector

    function _collectTokens(

        AuthCaptureEscrow.PaymentInfo calldata paymentInfo,

        address tokenStore,

        uint256 amount,

        bytes calldata collectorData

    ) internal virtual;

    /// @notice Get hash for PaymentInfo with null payer address

    ///

    /// @param paymentInfo PaymentInfo struct with non-null payer address

    ///

    /// @return hash Hash of PaymentInfo with payer replaced with zero address

    function _getHashPayerAgnostic(AuthCaptureEscrow.PaymentInfo memory paymentInfo) internal view returns (bytes32) {

        address payer = paymentInfo.payer;

        paymentInfo.payer = address(0);

        bytes32 hashPayerAgnostic = authCaptureEscrow.getHash(paymentInfo);

        // Proactively setting payer back to original value covers accidental bugs if memory location is then used elsewhere

        paymentInfo.payer = payer;

        return hashPayerAgnostic;

    }

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.9.0;

import {StdStorage} from "./StdStorage.sol";

import {Vm, VmSafe} from "./Vm.sol";

abstract contract CommonBase {

    /// @dev Cheat code address.

    /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.

    address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;

    /// @dev console.sol and console2.sol work by executing a staticcall to this address.

    /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.

    address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;

    /// @dev Used when deploying with create2.

    /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.

    address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;

    /// @dev The default address for tx.origin and msg.sender.

    /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.

    address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;

    /// @dev The address of the first contract `CREATE`d by a running test contract.

    /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.

    /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.

    address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;

    /// @dev Deterministic deployment address of the Multicall3 contract.

    /// Taken from https://www.multicall3.com.

    address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;

    /// @dev The order of the secp256k1 curve.

    uint256 internal constant SECP256K1_ORDER =

        115792089237316195423570985008687907852837564279074904382605163141518161494337;

    uint256 internal constant UINT256_MAX =

        115792089237316195423570985008687907853269984665640564039457584007913129639935;

    Vm internal constant vm = Vm(VM_ADDRESS);

    StdStorage internal stdstore;

}

abstract contract TestBase is CommonBase {}

abstract contract ScriptBase is CommonBase {

    VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.9.0;

pragma experimental ABIEncoderV2;

import {Vm} from "./Vm.sol";

abstract contract StdAssertions {

    event log(string);

    event logs(bytes);

    event log_address(address);

    event log_bytes32(bytes32);

    event log_int(int256);

    event log_uint(uint256);

    event log_bytes(bytes);

    event log_string(string);

    event log_named_address(string key, address val);

    event log_named_bytes32(string key, bytes32 val);

    event log_named_decimal_int(string key, int256 val, uint256 decimals);

    event log_named_decimal_uint(string key, uint256 val, uint256 decimals);

    event log_named_int(string key, int256 val);

    event log_named_uint(string key, uint256 val);

    event log_named_bytes(string key, bytes val);

    event log_named_string(string key, string val);

    event log_array(uint256[] val);

    event log_array(int256[] val);

    event log_array(address[] val);

    event log_named_array(string key, uint256[] val);

    event log_named_array(string key, int256[] val);

    event log_named_array(string key, address[] val);

    bool private _failed;

        } else {

        }

    }

    function fail() internal virtual {

        vm.store(address(vm), FAILED_SLOT, bytes32(uint256(1)));

        _failed = true;

    }

    function fail(string memory message) internal virtual {

        fail();

        vm.assertTrue(false, message);

    }

    function assertTrue(bool data) internal pure virtual {

        if (!data) {

            vm.assertTrue(data);

        }

    }

    function assertTrue(bool data, string memory err) internal pure virtual {

        if (!data) {

            vm.assertTrue(data, err);

        }

    }

    function assertFalse(bool data) internal pure virtual {

        if (data) {

            vm.assertFalse(data);

        }

    }

    function assertFalse(bool data, string memory err) internal pure virtual {

        if (data) {

            vm.assertFalse(data, err);

        }

    }

    function assertEq(bool left, bool right) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right);

        }

    }

    function assertEq(bool left, bool right, string memory err) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right, err);

        }

    }

    function assertEq(uint256 left, uint256 right) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right);

        }

    }

    function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right, err);

        }

    }

    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {

        vm.assertEqDecimal(left, right, decimals);

    }

    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertEqDecimal(left, right, decimals, err);

    }

    function assertEq(int256 left, int256 right) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right);

        }

    }

    function assertEq(int256 left, int256 right, string memory err) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right, err);

        }

    }

    function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

        vm.assertEqDecimal(left, right, decimals);

    }

    function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertEqDecimal(left, right, decimals, err);

    }

    function assertEq(address left, address right) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right);

        }

    }

    function assertEq(address left, address right, string memory err) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right, err);

        }

    }

    function assertEq(bytes32 left, bytes32 right) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right);

        }

    }

    function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right, err);

        }

    }

    function assertEq32(bytes32 left, bytes32 right) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right);

        }

    }

    function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {

        if (left != right) {

            vm.assertEq(left, right, err);

        }

    }

    function assertEq(string memory left, string memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(string memory left, string memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(bytes memory left, bytes memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(bool[] memory left, bool[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(int256[] memory left, int256[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(address[] memory left, address[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(string[] memory left, string[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual {

        vm.assertEq(left, right);

    }

    function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {

        vm.assertEq(left, right, err);

    }

    // Legacy helper

    function assertEqUint(uint256 left, uint256 right) internal pure virtual {

        assertEq(left, right);

    }

    function assertNotEq(bool left, bool right) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right);

        }

    }

    function assertNotEq(bool left, bool right, string memory err) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right, err);

        }

    }

    function assertNotEq(uint256 left, uint256 right) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right);

        }

    }

    function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right, err);

        }

    }

    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {

        vm.assertNotEqDecimal(left, right, decimals);

    }

    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err)

        internal

        pure

        virtual

    {

        vm.assertNotEqDecimal(left, right, decimals, err);

    }

    function assertNotEq(int256 left, int256 right) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right);

        }

    }

    function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right, err);

        }

    }

    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

        vm.assertNotEqDecimal(left, right, decimals);

    }

    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertNotEqDecimal(left, right, decimals, err);

    }

    function assertNotEq(address left, address right) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right);

        }

    }

    function assertNotEq(address left, address right, string memory err) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right, err);

        }

    }

    function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right);

        }

    }

    function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right, err);

        }

    }

    function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right);

        }

    }

    function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {

        if (left == right) {

            vm.assertNotEq(left, right, err);

        }

    }

    function assertNotEq(string memory left, string memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(bytes memory left, bytes memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(address[] memory left, address[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(string[] memory left, string[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual {

        vm.assertNotEq(left, right);

    }

    function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {

        vm.assertNotEq(left, right, err);

    }

    function assertLt(uint256 left, uint256 right) internal pure virtual {

        if (left >= right) {

            vm.assertLt(left, right);

        }

    }

    function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {

        if (left >= right) {

            vm.assertLt(left, right, err);

        }

    }

    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {

        vm.assertLtDecimal(left, right, decimals);

    }

    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertLtDecimal(left, right, decimals, err);

    }

    function assertLt(int256 left, int256 right) internal pure virtual {

        if (left >= right) {

            vm.assertLt(left, right);

        }

    }

    function assertLt(int256 left, int256 right, string memory err) internal pure virtual {

        if (left >= right) {

            vm.assertLt(left, right, err);

        }

    }

    function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

        vm.assertLtDecimal(left, right, decimals);

    }

    function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertLtDecimal(left, right, decimals, err);

    }

    function assertGt(uint256 left, uint256 right) internal pure virtual {

        if (left <= right) {

            vm.assertGt(left, right);

        }

    }

    function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {

        if (left <= right) {

            vm.assertGt(left, right, err);

        }

    }

    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {

        vm.assertGtDecimal(left, right, decimals);

    }

    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertGtDecimal(left, right, decimals, err);

    }

    function assertGt(int256 left, int256 right) internal pure virtual {

        if (left <= right) {

            vm.assertGt(left, right);

        }

    }

    function assertGt(int256 left, int256 right, string memory err) internal pure virtual {

        if (left <= right) {

            vm.assertGt(left, right, err);

        }

    }

    function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

        vm.assertGtDecimal(left, right, decimals);

    }

    function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertGtDecimal(left, right, decimals, err);

    }

    function assertLe(uint256 left, uint256 right) internal pure virtual {

        if (left > right) {

            vm.assertLe(left, right);

        }

    }

    function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {

        if (left > right) {

            vm.assertLe(left, right, err);

        }

    }

    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {

        vm.assertLeDecimal(left, right, decimals);

    }

    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertLeDecimal(left, right, decimals, err);

    }

    function assertLe(int256 left, int256 right) internal pure virtual {

        if (left > right) {

            vm.assertLe(left, right);

        }

    }

    function assertLe(int256 left, int256 right, string memory err) internal pure virtual {

        if (left > right) {

            vm.assertLe(left, right, err);

        }

    }

    function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

        vm.assertLeDecimal(left, right, decimals);

    }

    function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertLeDecimal(left, right, decimals, err);

    }

    function assertGe(uint256 left, uint256 right) internal pure virtual {

        if (left < right) {

            vm.assertGe(left, right);

        }

    }

    function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {

        if (left < right) {

            vm.assertGe(left, right, err);

        }

    }

    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {

        vm.assertGeDecimal(left, right, decimals);

    }

    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertGeDecimal(left, right, decimals, err);

    }

    function assertGe(int256 left, int256 right) internal pure virtual {

        if (left < right) {

            vm.assertGe(left, right);

        }

    }

    function assertGe(int256 left, int256 right, string memory err) internal pure virtual {

        if (left < right) {

            vm.assertGe(left, right, err);

        }

    }

    function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

        vm.assertGeDecimal(left, right, decimals);

    }

    function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {

        vm.assertGeDecimal(left, right, decimals, err);

    }

    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual {

        vm.assertApproxEqAbs(left, right, maxDelta);

    }

    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err) internal pure virtual {

        vm.assertApproxEqAbs(left, right, maxDelta, err);

    }

    function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals)

        internal

        pure

        virtual

    {

        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);

    }

    function assertApproxEqAbsDecimal(

        uint256 left,

        uint256 right,

        uint256 maxDelta,

        uint256 decimals,

        string memory err

    ) internal pure virtual {

        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);

    }

    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual {

        vm.assertApproxEqAbs(left, right, maxDelta);

    }

    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual {

        vm.assertApproxEqAbs(left, right, maxDelta, err);

    }

    function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals)

        internal

        pure

        virtual

    {

        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);

    }

    function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err)

        internal

        pure

        virtual

    {

        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);

    }

    function assertApproxEqRel(

        uint256 left,

        uint256 right,

        uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%

    )

        internal

        pure

        virtual

    {

        vm.assertApproxEqRel(left, right, maxPercentDelta);

    }

    function assertApproxEqRel(

        uint256 left,

        uint256 right,

        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%

        string memory err

    )

        internal

        pure

        virtual

    {

        vm.assertApproxEqRel(left, right, maxPercentDelta, err);

    }

    function assertApproxEqRelDecimal(

        uint256 left,

        uint256 right,

        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%

        uint256 decimals

    )

        internal

        pure

        virtual

    {

        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);

    }

    function assertApproxEqRelDecimal(

        uint256 left,

        uint256 right,

        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%

        uint256 decimals,

        string memory err

    ) internal pure virtual {

        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);

    }

    function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual {

        vm.assertApproxEqRel(left, right, maxPercentDelta);

    }

    function assertApproxEqRel(

        int256 left,

        int256 right,

        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%

        string memory err

    )

        internal

        pure

        virtual

    {

        vm.assertApproxEqRel(left, right, maxPercentDelta, err);

    }

    function assertApproxEqRelDecimal(

        int256 left,

        int256 right,

        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%

        uint256 decimals

    )

        internal

        pure

        virtual

    {

        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);

    }

    function assertApproxEqRelDecimal(

        int256 left,

        int256 right,

        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%

        uint256 decimals,

        string memory err

    ) internal pure virtual {

        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);

    }

    // Inherited from DSTest, not used but kept for backwards-compatibility

    function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool) {

        return keccak256(left) == keccak256(right);

    }

    function assertEq0(bytes memory left, bytes memory right) internal pure virtual {

        assertEq(left, right);

    }

    function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {

        assertEq(left, right, err);

    }

    function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual {

        assertNotEq(left, right);

    }

    function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {

        assertNotEq(left, right, err);

    }

    function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {

        assertEqCall(target, callDataA, target, callDataB, true);

    }

    function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)

        internal

        virtual

    {

        assertEqCall(targetA, callDataA, targetB, callDataB, true);

    }

    function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)

        internal

        virtual

    {

        assertEqCall(target, callDataA, target, callDataB, strictRevertData);

    }

    function assertEqCall(

        address targetA,

        bytes memory callDataA,

        address targetB,

        bytes memory callDataB,

        bool strictRevertData

    ) internal virtual {

        (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);

        (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);

        if (successA && successB) {

            assertEq(returnDataA, returnDataB, "Call return data does not match");

        }

        if (!successA && !successB && strictRevertData) {

            assertEq(returnDataA, returnDataB, "Call revert data does not match");

        }

        if (!successA && successB) {

            emit log("Error: Calls were not equal");

            emit log_named_bytes("  Left call revert data", returnDataA);

            emit log_named_bytes(" Right call return data", returnDataB);

            revert("assertion failed");

        }

        if (successA && !successB) {

            emit log("Error: Calls were not equal");

            emit log_named_bytes("  Left call return data", returnDataA);

            emit log_named_bytes(" Right call revert data", returnDataB);

            revert("assertion failed");

        }

    }

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.9.0;

pragma experimental ABIEncoderV2;

import {VmSafe} from "./Vm.sol";

/**

 * StdChains provides information about EVM compatible chains that can be used in scripts/tests.

 * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are

 * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of

 * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the

 * alias used in this contract, which can be found as the first argument to the

 * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.

 *

 * There are two main ways to use this contract:

 *   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or

 *      `setChain(string memory chainAlias, Chain memory chain)`

 *   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.

 *

 * The first time either of those are used, chains are initialized with the default set of RPC URLs.

 * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in

 * `defaultRpcUrls`.

 *

 * The `setChain` function is straightforward, and it simply saves off the given chain data.

 *

 * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say

 * we want to retrieve the RPC URL for `mainnet`:

 *   - If you have specified data with `setChain`, it will return that.

 *   - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it

 *     is valid (e.g. a URL is specified, or an environment variable is given and exists).

 *   - If neither of the above conditions is met, the default data is returned.

 *

 * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.

 */

abstract contract StdChains {

    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));

    bool private stdChainsInitialized;

    struct ChainData {

        string name;

        uint256 chainId;

        string rpcUrl;

    }

    struct Chain {

        // The chain name.

        string name;

        // The chain's Chain ID.

        uint256 chainId;

        // The chain's alias. (i.e. what gets specified in `foundry.toml`).

        string chainAlias;

        // A default RPC endpoint for this chain.

        // NOTE: This default RPC URL is included for convenience to facilitate quick tests and

        // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy

        // usage as you will be throttled and this is a disservice to others who need this endpoint.

        string rpcUrl;

    }

    // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.

    mapping(string => Chain) private chains;

    // Maps from the chain's alias to it's default RPC URL.

    mapping(string => string) private defaultRpcUrls;

    // Maps from a chain ID to it's alias.

    mapping(uint256 => string) private idToAlias;

    // The RPC URL will be fetched from config or defaultRpcUrls if possible.

    function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {

        require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");

        initializeStdChains();

        chain = chains[chainAlias];

        require(

            chain.chainId != 0,

            string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))

        );

        chain = getChainWithUpdatedRpcUrl(chainAlias, chain);

    }

    function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {

        require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");

        initializeStdChains();

        string memory chainAlias = idToAlias[chainId];

        chain = chains[chainAlias];

        require(

            chain.chainId != 0,

            string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))

        );

        chain = getChainWithUpdatedRpcUrl(chainAlias, chain);

    }

    // set chain info, with priority to argument's rpcUrl field.

    function setChain(string memory chainAlias, ChainData memory chain) internal virtual {

        require(

            bytes(chainAlias).length != 0,

            "StdChains setChain(string,ChainData): Chain alias cannot be the empty string."

        );

        require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");

        initializeStdChains();

        string memory foundAlias = idToAlias[chain.chainId];

        require(

            bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),

            string(

                abi.encodePacked(

                    "StdChains setChain(string,ChainData): Chain ID ",

                    vm.toString(chain.chainId),

                    " already used by \"",

                    foundAlias,

                    "\"."

                )

            )

        );

        uint256 oldChainId = chains[chainAlias].chainId;

        delete idToAlias[oldChainId];

        chains[chainAlias] =

            Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});

        idToAlias[chain.chainId] = chainAlias;

    }

    // set chain info, with priority to argument's rpcUrl field.

    function setChain(string memory chainAlias, Chain memory chain) internal virtual {

        setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));

    }

    function _toUpper(string memory str) private pure returns (string memory) {

        bytes memory strb = bytes(str);

        bytes memory copy = new bytes(strb.length);

        for (uint256 i = 0; i < strb.length; i++) {

            bytes1 b = strb[i];

            if (b >= 0x61 && b <= 0x7A) {

                copy[i] = bytes1(uint8(b) - 32);

            } else {

                copy[i] = b;

            }

        }

        return string(copy);

    }

    // lookup rpcUrl, in descending order of priority:

    // current -> config (foundry.toml) -> environment variable -> default

    function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)

        private

        view

        returns (Chain memory)

    {

        if (bytes(chain.rpcUrl).length == 0) {

            try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {

                chain.rpcUrl = configRpcUrl;

            } catch (bytes memory err) {

                string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));

                if (fallbackToDefaultRpcUrls) {

                    chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);

                } else {

                    chain.rpcUrl = vm.envString(envName);

                }

                // Distinguish 'not found' from 'cannot read'

                // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions

                bytes memory oldNotFoundError =

                    abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));

                bytes memory newNotFoundError = abi.encodeWithSignature(

                    "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))

                );

                bytes32 errHash = keccak256(err);

                if (

                    (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))

                        || bytes(chain.rpcUrl).length == 0

                ) {

                    /// @solidity memory-safe-assembly

                    assembly {

                        revert(add(32, err), mload(err))

                    }

                }

            }

        }

        return chain;

    }

    function setFallbackToDefaultRpcUrls(bool useDefault) internal {

        fallbackToDefaultRpcUrls = useDefault;

    }

    function initializeStdChains() private {

        if (stdChainsInitialized) return;

        stdChainsInitialized = true;

        // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`

        setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));

        setChainWithDefaultRpcUrl("mainnet", ChainData("Mainnet", 1, "https://eth.llamarpc.com"));

        setChainWithDefaultRpcUrl(

            "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")

        );

        setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io"));

        setChainWithDefaultRpcUrl("hoodi", ChainData("Hoodi", 560048, "https://rpc.hoodi.ethpandaops.io"));

        setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));

        setChainWithDefaultRpcUrl(

            "optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io")

        );

        setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));

        setChainWithDefaultRpcUrl(

            "arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc")

        );

        setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));

        setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));

        setChainWithDefaultRpcUrl(

            "polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology")

        );

        setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));

        setChainWithDefaultRpcUrl(

            "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")

        );

        setChainWithDefaultRpcUrl(

            "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")

        );

        setChainWithDefaultRpcUrl(

            "bnb_smart_chain_testnet",

            ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")

        );

        setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));

        setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));

        setChainWithDefaultRpcUrl(

            "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")

        );

        setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));

        setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org"));

        setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));

        setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io"));

        setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io"));

        setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/"));

        setChainWithDefaultRpcUrl(

            "fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/")

        );

        setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com"));

        setChainWithDefaultRpcUrl("fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com"));

        setChainWithDefaultRpcUrl(

            "berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com")

        );

        setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc"));

        setChainWithDefaultRpcUrl(

            "flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc")

        );

        setChainWithDefaultRpcUrl("ink", ChainData("Ink", 57073, "https://rpc-gel.inkonchain.com"));

        setChainWithDefaultRpcUrl(

            "ink_sepolia", ChainData("Ink Sepolia", 763373, "https://rpc-gel-sepolia.inkonchain.com")

        );

        setChainWithDefaultRpcUrl("mode", ChainData("Mode", 34443, "https://mode.drpc.org"));

        setChainWithDefaultRpcUrl("mode_sepolia", ChainData("Mode Sepolia", 919, "https://sepolia.mode.network"));

        setChainWithDefaultRpcUrl("zora", ChainData("Zora", 7777777, "https://zora.drpc.org"));

        setChainWithDefaultRpcUrl(

            "zora_sepolia", ChainData("Zora Sepolia", 999999999, "https://sepolia.rpc.zora.energy")

        );

        setChainWithDefaultRpcUrl("race", ChainData("Race", 6805, "https://racemainnet.io"));

        setChainWithDefaultRpcUrl("race_sepolia", ChainData("Race Sepolia", 6806, "https://racemainnet.io"));

        setChainWithDefaultRpcUrl("metal", ChainData("Metal", 1750, "https://metall2.drpc.org"));

        setChainWithDefaultRpcUrl("metal_sepolia", ChainData("Metal Sepolia", 1740, "https://testnet.rpc.metall2.com"));

        setChainWithDefaultRpcUrl("binary", ChainData("Binary", 624, "https://rpc.zero.thebinaryholdings.com"));

        setChainWithDefaultRpcUrl(

            "binary_sepolia", ChainData("Binary Sepolia", 625, "https://rpc.zero.thebinaryholdings.com")

        );

        setChainWithDefaultRpcUrl("orderly", ChainData("Orderly", 291, "https://rpc.orderly.network"));

        setChainWithDefaultRpcUrl(

            "orderly_sepolia", ChainData("Orderly Sepolia", 4460, "https://testnet-rpc.orderly.org")

        );

        setChainWithDefaultRpcUrl("unichain", ChainData("Unichain", 130, "https://mainnet.unichain.org"));

        setChainWithDefaultRpcUrl(

            "unichain_sepolia", ChainData("Unichain Sepolia", 1301, "https://sepolia.unichain.org")

        );

    }

    // set chain info, with priority to chainAlias' rpc url in foundry.toml

    function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {

        string memory rpcUrl = chain.rpcUrl;

        defaultRpcUrls[chainAlias] = rpcUrl;

        chain.rpcUrl = "";

        setChain(chainAlias, chain);

        chain.rpcUrl = rpcUrl; // restore argument

    }

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.9.0;

pragma experimental ABIEncoderV2;

import {StdStorage, stdStorage} from "./StdStorage.sol";

import {console2} from "./console2.sol";

import {Vm} from "./Vm.sol";

abstract contract StdCheatsSafe {

    Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

    uint256 private constant UINT256_MAX =

        115792089237316195423570985008687907853269984665640564039457584007913129639935;

    bool private gasMeteringOff;

    // Data structures to parse Transaction objects from the broadcast artifact

    // that conform to EIP1559. The Raw structs is what is parsed from the JSON

    // and then converted to the one that is used by the user for better UX.

    struct RawTx1559 {

        string[] arguments;

        address contractAddress;

        string contractName;

        // json value name = function

        string functionSig;

        bytes32 hash;

        // json value name = tx

        RawTx1559Detail txDetail;

        // json value name = type

        string opcode;

    }

    struct RawTx1559Detail {

        AccessList[] accessList;

        bytes data;

        address from;

        bytes gas;

        bytes nonce;

        address to;

        bytes txType;

        bytes value;

    }

    struct Tx1559 {

        string[] arguments;

        address contractAddress;

        string contractName;

        string functionSig;

        bytes32 hash;

        Tx1559Detail txDetail;

        string opcode;

    }

    struct Tx1559Detail {

        AccessList[] accessList;

        bytes data;

        address from;

        uint256 gas;

        uint256 nonce;